﻿#define _CRT_SECURE_NO_WARNINGS
#include <iostream> //标准输入输出流
#include <string> //字符串处理
#include <vector> //动态数组容器
#include <filesystem> //文件系统操作（c++17）
#include <fstream> //文件流操作
#include <algorithm> //算法函数，如find_if
#include <cctype> //字符处理函数
#include <limits> //数值极限
#include <sstream> // 用于分割字符串
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <chrono>
#include <thread>

namespace fs = std::filesystem;// 简化filesystem命名空间

// 清除输入缓冲区
static void clearInputBuffer() {
    //std::cin.ignore()从输入流中忽略字符
    //std::numeric_limits<std::streamsize>::max()//尽可能多地忽略字符,直到遇到分隔符（'\n'）或达到系统限制
    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}

// 文件系统类 - 处理所有文件和目录操作
class FileSystem {
//成员变量
private:
    fs::path currentPath;//当前工作路径

//构造函数
public:
    //初始化时将当前路径 设为程序运行时的当前工作目录
    FileSystem() : currentPath(fs::current_path()) {}

    // 获取当前路径
    fs::path getCurrentPath() const { //const:常量成员函数，不会修改成员变量
        return currentPath;
    }

    // 添加格式化显示路径的方法
    std::string getFormattedPath() const {
        std::string pathStr = currentPath.generic_string();

        // windows系统特判：将路径格式化为适配Windows系统的形式，如/C//User转为C:\\User
        //#ifdef _WIN32：条件编译，只在windows平台触发
        #ifdef _WIN32
        if (pathStr.size() > 1 && pathStr[0] == '/' && pathStr[2] == '/') {
            pathStr[0] = pathStr[1];
            pathStr[1] = ':';
            pathStr.erase(2, 1);
        }
        #endif

        return pathStr;
    }

    // 改变当前目录
    // const:表示dirName是一个常量，函数内部不能修改它的值，
    // std::string&表示dirName是一个引用，指向传入的字符串对象，而不是拷贝一份新的字符串，提高效率
    bool changeDirectory(const std::string& dirName) {
        try {
            // 处理绝对路径和相对路径
            fs::path newPath = dirName;
            if (!newPath.is_absolute()) {
                newPath = currentPath / newPath;
            }

            // 规范化路径，消除 . 和 ..
            newPath = fs::weakly_canonical(newPath);

            // 检查路径是否存在且为目录
            if (!fs::exists(newPath)) {
                std::cout << "错误：路径不存在 - " << newPath << std::endl;
                return false;
            }

            if (!fs::is_directory(newPath)) {
                std::cout << "错误：'" << newPath.filename() << "' 不是目录" << std::endl;
                return false;
            }

            // 切换目录并显示成功信息
            currentPath = newPath;
            std::cout << "已切换到目录：" << currentPath << std::endl;
            return true;
        }
        catch (const fs::filesystem_error& e) {
            // 处理各种文件系统异常
            const auto& ec = e.code();

            if (ec == std::errc::permission_denied) {
                std::cout << "错误：权限不足，无法访问目录" << std::endl;
            }
            else if (ec == std::errc::invalid_argument) {
                std::cout << "错误：非法路径格式" << std::endl;
            }
            else {
                std::cout << "错误：" << e.what() << std::endl;
            }

            return false;
        }
    }

    // 返回上级目录
    bool goUp() {
        try {
            // 检查当前路径是否存在父目录
            if (currentPath.has_parent_path()) {
                // 获取父目录路径
                auto parent = currentPath.parent_path();

                // 输出路径变更信息（源路径 -> 目标路径）
                std::cout << "从 [" << currentPath << "] 切换到父目录 [" << parent << "]" << std::endl;

                // 更新当前路径为父目录
                currentPath = parent;
                return true;
            }

            // 处理已在根目录的情况
            std::cout << "已经是根目录！" << std::endl;
            return false;

        }
        catch (const std::exception& e) {
            // 捕获并处理可能的异常（如文件系统权限问题）
            std::cerr << "目录切换失败: " << e.what() << std::endl;
            return false;
        }
    }

    // 显示文件目录
    void displayDirectory() const { //const：表示这是一个不会修改类成员变量的只读操作
        std::cout << "\n当前目录: " << currentPath << std::endl;
        std::cout << "----------------------------------------" << std::endl;

        int count = 0;
        for (const auto& entry : fs::directory_iterator(currentPath)) {
            std::cout << (++count) << ". ";
            if (entry.is_directory()) {
                std::cout << "[目录] ";
            }
            else {
                std::cout << "[文件] ";
            }
            std::cout << entry.path().filename() << std::endl;
        }

        if (count == 0) {
            std::cout << "目录为空。" << std::endl;
        }
        std::cout << "----------------------------------------" << std::endl;
    }

   // 创建新文件
    bool createFile(const std::string& fileName) const {
        fs::path filePath = currentPath / fileName;//构造文件路径

        // 检查路径有效性
        if (filePath.has_parent_path() && !fs::exists(filePath.parent_path())) {
            std::cout << "提示：父目录不存在，尝试创建目录结构..." << std::endl;

            try {
                fs::create_directories(filePath.parent_path()); //递归创建目录
                std::cout << "目录结构创建成功: " << filePath.parent_path() << std::endl;
            }
            catch (const fs::filesystem_error& e) {
                std::cout << "错误：无法创建目录结构 - " << e.what() << std::endl;
                return false;
            }
        }
            
        if (fs::exists(filePath)) {//检查文件是否已经存在
            std::cout << "错误：文件已存在！" << std::endl;
            return false;
        }

        try {
            // std::ofstream:创建并写入文件的输出流，构造函数直接传入路径，尝试创建文件
            std::ofstream file(filePath);
            if (file.is_open()) {//检查是否成功打开，确认文件是否真正创建
                file.close();//立即关闭，释放资源
                std::cout << "文件 '" << fileName << "' 创建成功！" << std::endl;
                return true;
            }
        }
        //fs::filesystem_error：文件系统操作（如权限不足、路径无效）抛出的异常
        catch (const fs::filesystem_error& e) {
            //e.what() 提供具体的失败原因（如 "Permission denied"）
            std::cout << "错误：创建文件失败 - " << e.what() << std::endl;
        }

        //可改进：
        //2/更详细的错误信息：区分“权限不足”，“路径无效”等错误类型
        return false;
    }

    // 删除文件
    bool deleteFile(const std::string& fileName) const {
        fs::path filePath = currentPath / fileName;

        try {
            // 检查文件是否存在且为普通文件
            if (!fs::exists(filePath)) {
                std::cout << "错误：文件 '" << fileName << "' 不存在！" << std::endl;
                return false;
            }

            if (!fs::is_regular_file(filePath)) {
                // 区分目录和其他类型的文件
                if (fs::is_directory(filePath)) {
                    std::cout << "错误：'" << fileName << "' 是目录，使用 'rmdir' 命令删除目录！" << std::endl;
                }
                else {
                    std::cout << "错误：'" << fileName << "' 不是普通文件！" << std::endl;
                }
                return false;
            }

            // 尝试删除文件
            bool success = fs::remove(filePath);

            if (!success) {
                std::cout << "错误：无法删除文件 '" << fileName << "'，可能被其他程序占用！" << std::endl;
                return false;
            }

            std::cout << "文件 '" << fileName << "' 删除成功！" << std::endl;
            return true;
        }
        catch (const fs::filesystem_error& e) {
            // 明确分类常见错误
            auto errorCode = e.code().value();

            switch (errorCode) {
            case static_cast<int>(std::errc::permission_denied):
                std::cout << "错误：权限不足，无法删除文件 '" << fileName << "'！" << std::endl;
                break;

            case static_cast<int>(std::errc::no_such_file_or_directory):
                /*理论上不会执行到这里，因为前面已经检查过文件存在性，
                但是在多线程或多进程环境中，文件状态可能在检查后、操作前被其他程序修改，故重复*/ 
                std::cout << "错误：文件 '" << fileName << "' 在操作过程中被删除！" << std::endl;
                break;

            case static_cast<int>(std::errc::directory_not_empty):
                // 理论上不会执行到这里，因为前面已经检查过是普通文件
                std::cout << "错误：'" << fileName << "' 是目录，而非文件！" << std::endl;
                break;

            case static_cast<int>(std::errc::device_or_resource_busy):
                std::cout << "错误：文件 '" << fileName << "' 正在被使用，无法删除！" << std::endl;
                break;

            default:
                std::cout << "错误：删除文件失败 - " << e.what() << std::endl;
                break;
            }

            return false;
        }
    }

    // 创建目录
    bool createDirectory(const std::string& dirName) const {
        try {
            // 1. 路径规范化处理
            fs::path dirPath = currentPath / dirName;
            dirPath = fs::weakly_canonical(dirPath); // 消除 . 和 .. 等冗余符号

            // 2. 检查目标是否已存在
            if (fs::exists(dirPath)) {
                if (fs::is_directory(dirPath)) {
                    std::cout << "警告：目录 '" << dirPath.filename() << "' 已存在！" << std::endl;
                    return true; // 可选：已存在时返回成功
                }
                else {
                    std::cout << "错误：'" << dirPath.filename() << "' 已存在但不是目录！" << std::endl;
                    return false;
                }
            }

            // 3. 递归创建目录（包括所有父目录）
            fs::create_directories(dirPath);

            std::cout << "目录 '" << dirName << "' 创建成功！" << std::endl;
            return true;
        }
        catch (const fs::filesystem_error& e) {
            // 4. 错误分类处理
            const auto& ec = e.code();

            if (ec == std::errc::permission_denied) {
                std::cout << "错误：权限不足，无法创建目录 '" << dirName << "'！" << std::endl;
            }
            else if (ec == std::errc::no_such_file_or_directory) {
                std::cout << "错误：父路径无效或包含非法字符！" << std::endl;
            }
            else if (ec == std::errc::invalid_argument) {
                std::cout << "错误：目录名 '" << dirName << "' 包含非法字符！" << std::endl;
            }
            else if (ec == std::errc::file_exists) {
                // 理论上不会执行到这里，因为前面已检查
                std::cout << "错误：'" << dirName << "' 已存在且不是目录！" << std::endl;
            }
            else {
                std::cout << "错误：创建目录失败 - " << e.what() << std::endl;
            }

            return false;
        }
    }

    // 删除目录
    bool deleteDirectory(const std::string& dirName) const {
        fs::path dirPath = currentPath / dirName;

        try {
            // 检查目录是否存在
            if (!fs::exists(dirPath)) {
                std::cout << "错误：目录 '" << dirName << "' 不存在！" << std::endl;
                return false;
            }

            if (!fs::is_directory(dirPath)) {
                // 区分文件和其他类型
                if (fs::is_regular_file(dirPath)) {
                    std::cout << "错误：'" << dirName << "' 是普通文件，使用 'delete' 命令删除文件！" << std::endl;
                }
                else {
                    std::cout << "错误：'" << dirName << "' 不是目录！" << std::endl;
                }
                return false;
            }

            // 确认删除操作
            char confirm;
            std::cout << "警告：删除目录 '" << dirName << "' 将递归删除其所有内容。是否继续？(y/n): ";
            std::cin >> confirm;
            clearInputBuffer();

            if (std::tolower(confirm) != 'y') {
                std::cout << "操作已取消。" << std::endl;
                return false;
            }

            // 递归删除目录
            size_t numRemoved = fs::remove_all(dirPath);
            std::cout << "目录 '" << dirName << "' 已成功删除，共删除 " << numRemoved << " 个文件/目录。" << std::endl;
            return true;
        }
        catch (const fs::filesystem_error& e) {
            // 错误分类处理
            auto errorCode = e.code().value();

            switch (errorCode) {
            case static_cast<int>(std::errc::permission_denied):
                std::cout << "错误：权限不足，无法删除目录 '" << dirName << "'！" << std::endl;
                break;

            case static_cast<int>(std::errc::directory_not_empty):
                // 理论上不会执行到这里，因为 remove_all 可以处理非空目录
                std::cout << "错误：目录 '" << dirName << "' 非空！" << std::endl;
                break;

            case static_cast<int>(std::errc::no_such_file_or_directory):
                // 理论上不会执行到这里，因为前面已经检查过存在性
                std::cout << "错误：目录 '" << dirName << "' 在操作过程中被删除！" << std::endl;
                break;

            case static_cast<int>(std::errc::device_or_resource_busy):
                std::cout << "错误：目录 '" << dirName << "' 或其内容正在被使用，无法删除！" << std::endl;
                break;

            case static_cast<int>(std::errc::invalid_argument):
                std::cout << "错误：目录名 '" << dirName << "' 包含非法字符！" << std::endl;
                break;

            default:
                std::cout << "错误：删除目录失败 - " << e.what() << std::endl;
                break;
            }

            return false;
        }
    }

    // 重命名文件/目录
    bool rename(const std::string& oldName, const std::string& newName) const {
        fs::path oldPath = currentPath / oldName;
        fs::path newPath = currentPath / newName;

        // 检查源文件是否存在
        if (!fs::exists(oldPath)) {
            std::cout << "错误：源文件/目录不存在！" << std::endl;
            return false;
        }

        // 检查新命名和其他文件名有无冲突
        if (fs::exists(newPath)) {
            std::cout << "错误：目标文件/目录已存在！" << std::endl;
            return false;
        }

        try {
            fs::rename(oldPath, newPath);
            std::cout << "已将 '" << oldName << "' 重命名为 '" << newName << "'。" << std::endl;
            return true;
        }
        catch (const fs::filesystem_error& e) {
            std::cout << "错误：重命名失败 - " << e.what() << std::endl;
        }
        return false;
    }

    // 显示文件内容
    bool displayFileContent(const std::string& fileName) const {
        fs::path filePath = currentPath / fileName;
        // 检查文件是否存在以及能否写入（是否为常规文件）
        if (!fs::is_regular_file(filePath)) {
            std::cout << "错误：文件不存在或不是常规文件！" << std::endl;
            return false;
        }
        // 可改进：指出该非常规文件是什么类型的文件

        try {
            std::ifstream file(filePath);
            if (file.is_open()) {
                std::cout << "\n文件 '" << fileName << "' 的内容：" << std::endl;
                std::cout << "----------------------------------------" << std::endl;
                std::string line;
                while (std::getline(file, line)) {
                    std::cout << line << std::endl;
                }
                std::cout << "----------------------------------------" << std::endl;
                file.close();
                return true;
            }
            else {
                std::cout << "错误：无法打开文件！" << std::endl;
            }
        }
        catch (const std::exception& e) {
            std::cout << "错误：读取文件失败 - " << e.what() << std::endl;
        }
        return false;
    }

    // 写入文件内容
    //fileName：文件名； content：要写入的内容；  append：是否追加模式（默认覆盖模式）
    bool writeFileContent(const std::string& fileName, bool append = false) const {
        fs::path filePath = currentPath / fileName;

        // 检查文件路径是否有效
        if (!fs::is_directory(currentPath)) {
            std::cerr << "错误：当前路径不是有效的目录！" << std::endl;
            return false;
        }

        // 检查文件是否存在:若覆盖模式下文件不存在，创建文件并继续程序；追加模式下再报错
        if (append && !fs::is_regular_file(filePath)) {
               std::cout << "错误：文件不存在！" << std::endl;
               return false;
        }else if(!append && !fs::is_regular_file(filePath)){
               if (!createFile(fileName)) {
                   std::cerr << "错误：无法创建文件 '" << fileName << "'！" << std::endl;
                   return false;
               }
            }

        // 提示用户输入内容
        std::string content;        // 内容
        std::string line;           // 临时变量，一行文本
        std::cout << "文件 '" << fileName << "' 存在，请输入要"
            << (append ? "追加" : "覆盖") << "的内容（末行输入:wq结束）：" << std::endl;
        // 逐行读取用户输入，直到文件结束符（:wq）
        while (std::getline(std::cin, line) && line != ":wq") {
            content += line + "\n"; // 添加换行符，保持与原代码一致
        }
        // 无输入操作
        if (content.empty()) {
            std::cout << "未输入内容，操作已取消。" << std::endl;
            return false;
        }

        //将内容写入文件
        try {
            std::ofstream file;
            if (append) {
                file.open(filePath, std::ios::app);     // 文件以 std::ios::app 模式打开，新内容会被添加到文件末尾
            }
            else {
                file.open(filePath);
            }

            if (file.is_open()) {
                file << content;
                file.close();
                std::cout << "文件 '" << fileName << "' 内容已" << (append ? "追加" : "更新") << "！" << std::endl;
                return true;
            }
            else {
                std::cout << "错误：无法打开文件！" << std::endl;
            }
        }
        catch (const std::exception& e) {
            std::cout << "错误：写入文件失败 - " << e.what() << std::endl;
        }
        return false;
    }

    // 复制文件
    bool copyFile(const std::string& sourceName, const std::string& destName) const {
        fs::path sourcePath = currentPath / sourceName;
        fs::path destPath = currentPath / destName;

        // 检查源文件是否存在
        if (!fs::is_regular_file(sourcePath)) {
            std::cout << "错误：源文件不存在！" << std::endl;
            return false;
        }

        // 检查目标文件是否存在
        if (fs::exists(destPath)) {
            std::cout << "错误：目标文件已存在！" << std::endl;
            return false;
        }

        try {
            fs::copy_file(sourcePath, destPath);
            std::cout << "文件 '" << sourceName << "' 已复制到 '" << destName << "'" << std::endl;
            return true;
        }
        catch (const fs::filesystem_error& e) {
            std::cout << "错误：复制文件失败 - " << e.what() << std::endl;
        }
        return false;
    }

    // 移动文件
    // path可以自动解析 .. 
    bool moveFile(const std::string& sourceName, const std::string& destName) const {
        fs::path sourcePath = currentPath / sourceName;
        fs::path destPath = destName;

        // 目标位置，相对路径变为绝对路径
        if (destPath.is_relative()) {
            destPath = currentPath / destPath;
        }

        // 检查源文件是否存在
        if (!fs::exists(sourcePath)) {
            std::cout << "错误：源文件不存在！" << std::endl;
            return false;
        }

        // 检查目标文件是否已存在
        if (fs::exists(destPath)) {
            std::cout << "错误：目标文件已存在！" << std::endl;
            return false;
        }

        // 若目标目录不存在，创建目标目录
        fs::path destDir = destPath.parent_path();
        if (!fs::exists(destDir)) {
            try {
                fs::create_directories(destDir);
                // lexically_normal()规范化路径格式，处理多余的分隔符或 . 和 ..符号或混合分隔符
                std::cout << "已创建目录: " << destDir.lexically_normal() << std::endl;
            }
            catch (const fs::filesystem_error& e) {
                std::cout << "错误：创建目录失败 - " << e.what() << std::endl;
                return false;
            }
        }

        // 移动文件
        try {
            // rename(): 在同一目录下更改文件名；不同目录下移动文件
            fs::rename(sourcePath, destPath);
            std::cout << "文件 '" << sourceName << "' 已移动到 '"
                << destPath.lexically_normal() << "'。" << std::endl;
            return true;
        }
        catch (const fs::filesystem_error& e) {
            std::cout << "错误：移动文件失败 - " << e.what() << std::endl;
        }
        return false;
    }

    // 获取文件大小
    // uintmax_t无符号整数类型，表示文件大小（字节数）
    uintmax_t getFileSize(const std::string& fileName) const {
        fs::path filePath = currentPath / fileName;
        if (!fs::exists(filePath)) {
            return 0;
        }

        try {
            return fs::file_size(filePath);
        }
        catch (const fs::filesystem_error& e) {
            std::cout << "错误：获取文件大小失败 - " << e.what() << std::endl;
            return 0;
        }
    }
};


// 用户界面类 - 处理所有用户交互
class UserInterface {
private:
    FileSystem fileSystem;// 文件系统操作核心类
    bool running;// 程序运行状态标志

public:
    UserInterface() : running(true) {}// 初始化时设置运行状态为true

    // 显示帮助菜单
    void showMenu() const {
        std::cout << "\n";
        std::cout << "╔══════════════════════════════════════════════════════╗\n";
        std::cout << "║            文件资源管理器 - 操作菜单                 ║\n";
        std::cout << "╠════════════════════╦═════════════════════════════════╣\n";
        std::cout << "║     命令           ║             功能描述            ║\n";
        std::cout << "╠════════════════════╬═════════════════════════════════╣\n";

        // 设置左对齐并固定列宽
        std::cout << std::left;
        std::cout << "║ " << std::setw(19) << "ls" << "║ " << std::setw(32) << "显示文件目录" << "║\n";
        std::cout << "║ " << std::setw(19) << "nf <文件>" << "║ " << std::setw(32) << "创建新文件" << "║\n";
        std::cout << "║ " << std::setw(19) << "del <文件>" << "║ " << std::setw(32) << "删除文件" << "║\n";
        std::cout << "║ " << std::setw(19) << "mkdir <目录>" << "║ " << std::setw(32) << "创建新目录" << "║\n";
        std::cout << "║ " << std::setw(19) << "rmdir <目录>" << "║ " << std::setw(32) << "删除目录" << "║\n";
        std::cout << "║ " << std::setw(19) << "rn <旧名> <新名>" << "║ " << std::setw(32) << "重命名文件/目录" << "║\n";
        std::cout << "║ " << std::setw(19) << "type <文件>" << "║ " << std::setw(32) << "显示文件内容" << "║\n";
        std::cout << "║ " << std::setw(19) << "write <文件>" << "║ " << std::setw(32) << "写入文件内容" << "║\n";
        std::cout << "║ " << std::setw(19) << "append <文件>" << "║ " << std::setw(32) << "追加内容到文件" << "║\n";
        std::cout << "║ " << std::setw(19) << "cp <源> <目标>" << "║ " << std::setw(32) << "复制文件" << "║\n";
        std::cout << "║ " << std::setw(19) << "mv <源> <目标>" << "║ " << std::setw(32) << "移动文件" << "║\n";
        std::cout << "║ " << std::setw(19) << "cd <目录>" << "║ " << std::setw(32) << "进入目录" << "║\n";
        std::cout << "║ " << std::setw(19) << "cd.." << "║ " << std::setw(32) << "返回上级目录" << "║\n";
        std::cout << "║ " << std::setw(19) << "info <文件>" << "║ " << std::setw(32) << "查看文件信息" << "║\n";
        std::cout << "║ " << std::setw(19) << "exit" << "║ " << std::setw(32) << "退出程序" << "║\n";
        std::cout << "╚════════════════════╩═════════════════════════════════╝\n";
    }

    void curPath() {
        std::cout << fileSystem.getFormattedPath() << ">";
    }
     
    // 运行资源管理器
    void run() {
        std::string input;//存储用户输入
        std::vector<std::string> args; //存储分割后的命令和参数

        while (running) {
            curPath();//展示当前目录
            std::getline(std::cin, input);

            std::stringstream ss(input);// 分割输入为命令和参数
            std::string token;
            args.clear();

            while (ss >> token) {
                // 依次存入命令和文件/目录名
                args.push_back(token);
            }

            if (args.empty()) {// 如果没有输入，继续循环
                continue;
            }

            std::string command = args[0];// 获取命令

            // 处理命令
            if (command == "ls") {
                //std::cout << "显示文件目录" << std::endl;
                fileSystem.displayDirectory();
            }
            else if (command == "nf" && args.size() > 1) {
                //std::cout << "创建文件：" << args[1] << std::endl;
                fileSystem.createFile(args[1]);
            }
            else if (command == "del" && args.size() > 1) {
                // //std::cout << "删除文件：" << args[1] << std::endl;
                fileSystem.deleteFile(args[1]);
            }
            else if (command == "mkdir" && args.size() > 1) {
                //std::cout << "创建新目录：" << args[1] << std::endl;
                fileSystem.createDirectory(args[1]);
            }
            else if (command == "rmdir" && args.size() > 1) {
                //std::cout << "删除目录：" << args[1] << std::endl;
                fileSystem.deleteDirectory(args[1]);
            }
            else if (command == "rn" && args.size() > 2) {
                //std::cout << "重命名文件/目录：" << args[1] << "->" << args[2] << std::endl;
                fileSystem.rename(args[1], args[2]);
            }
            else if (command == "type" && args.size() > 1) {
                //std::cout << "显示文件内容：" << args[1] << std::endl;
                fileSystem.displayFileContent(args[1]);
            }
            else if (command == "write" && args.size() > 1) {
                //std::cout << "写入文件内容：" << args[1] << std::endl;
                fileSystem.writeFileContent(args[1], false);
            }
            else if (command == "append" && args.size() > 1) {
                //std::cout << "追加内容到文件：" << args[1] << std::endl;
                fileSystem.writeFileContent(args[1], true);
            }
            else if (command == "cp" && args.size() > 2) {
                //std::cout << "复制文件：" << args[1] << "->" << args[2] << std::endl;
                fileSystem.copyFile(args[1], args[2]);
            }
            else if (command == "mv" && args.size() > 2) {
                //std::cout << "移动文件：" << args[1] << "->" << args[2] << std::endl;
                fileSystem.moveFile(args[1], args[2]);
            }
            else if (command == "cd" && args.size() > 1) {
                //std::cout << "进入目录：" << args[1] << std::endl;
                fileSystem.changeDirectory(args[1]);
            }
            else if (command == "cd" && args.size() == 2 && args[1] == "..") {
                //std::cout << "返回上级目录：" << std::endl;
                fileSystem.goUp();
            }
            else if (command == "info" && args.size() > 1) {
                //std::cout << "查看文件信息：" << args[1] << std::endl;
                std::cout << "文件" << args[1] << "的大小为:" 
                    << fileSystem.getFileSize(args[1]) << "B" << std::endl;
            }
            else if (command == "exit") {
                std::cout << "退出系统\n";
                exit(0);
            }
            else {
                std::cout << "指令不存在\n";
                continue;
            }
        }
    }

    // 开屏动画（C++风格）
    void showWelcome() {
        // 使用C++随机数库
        std::srand(static_cast<unsigned>(std::time(nullptr)));

        bool shouldContinue = true;

        // 使用范围for循环和现代C++类型
        for (int row = 0; row <= 80 && shouldContinue; ++row) {
            for (int col = 0; col <= 70; ++col) {
                int randomValue = std::rand() % 7;

                if (randomValue >= 4) {
                    // 使用C++的随机布尔值和条件运算符
                    char displayChar = (std::rand() % 2) ? '*' : 'o';
                    // 使用C++的格式化输出
                    std::cout << std::left << std::setw(std::rand() % 4 + 2) << displayChar;
                }
                else if (row == 80) {
                    shouldContinue = false;
                }
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 每行间隔50ms
        }

        // 使用C++的跨平台清屏方法
#ifdef _WIN32
        std::system("cls");
#else
        std::system("clear");
#endif

    }
};

int main() {
    UserInterface ui;
    ui.showWelcome();
    ui.showMenu();
    ui.run();
    return 0;
}